YES 1.7870000000000001 H-Termination proof of /home/matraf/haskell/eval_FullyBlown_Fast/List.hs
H-Termination of the given Haskell-Program with start terms could successfully be proven:



HASKELL
  ↳ LR

mainModule List
  ((transpose :: [[a]]  ->  [[a]]) :: [[a]]  ->  [[a]])

module List where
  import qualified Maybe
import qualified Prelude

  transpose :: [[a]]  ->  [[a]]
transpose [] []
transpose ([] : xsstranspose xss
transpose ((x : xs: xss(x : concatMap (\vv3 ->
case vv3 of
  h : t-> h : []
  _-> []
) xss: transpose (xs : concatMap (\vv4 ->
case vv4 of
  h : t-> t : []
  _-> []
) xss)


module Maybe where
  import qualified List
import qualified Prelude



Lambda Reductions:
The following Lambda expression
\vv3
case vv3 of
 h : t → h : []
 _ → []

is transformed to
transpose0 vv3 = 
case vv3 of
 h : t → h : []
 _ → []

The following Lambda expression
\vv4
case vv4 of
 h : t → t : []
 _ → []

is transformed to
transpose1 vv4 = 
case vv4 of
 h : t → t : []
 _ → []



↳ HASKELL
  ↳ LR
HASKELL
      ↳ CR

mainModule List
  ((transpose :: [[a]]  ->  [[a]]) :: [[a]]  ->  [[a]])

module List where
  import qualified Maybe
import qualified Prelude

  transpose :: [[a]]  ->  [[a]]
transpose [] []
transpose ([] : xsstranspose xss
transpose ((x : xs: xss(x : concatMap transpose0 xss: transpose (xs : concatMap transpose1 xss)

  
transpose0 vv3 
case vv3 of
  h : t-> h : []
  _-> []

  
transpose1 vv4 
case vv4 of
  h : t-> t : []
  _-> []


module Maybe where
  import qualified List
import qualified Prelude



Case Reductions:
The following Case expression
case vv3 of
 h : t → h : []
 _ → []

is transformed to
transpose00 (h : t) = h : []
transpose00 _ = []

The following Case expression
case vv4 of
 h : t → t : []
 _ → []

is transformed to
transpose10 (h : t) = t : []
transpose10 _ = []



↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ CR
HASKELL
          ↳ BR

mainModule List
  ((transpose :: [[a]]  ->  [[a]]) :: [[a]]  ->  [[a]])

module List where
  import qualified Maybe
import qualified Prelude

  transpose :: [[a]]  ->  [[a]]
transpose [] []
transpose ([] : xsstranspose xss
transpose ((x : xs: xss(x : concatMap transpose0 xss: transpose (xs : concatMap transpose1 xss)

  
transpose0 vv3 transpose00 vv3

  
transpose00 (h : th : []
transpose00 []

  
transpose1 vv4 transpose10 vv4

  
transpose10 (h : tt : []
transpose10 []


module Maybe where
  import qualified List
import qualified Prelude



Replaced joker patterns by fresh variables and removed binding patterns.

↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ CR
        ↳ HASKELL
          ↳ BR
HASKELL
              ↳ COR

mainModule List
  ((transpose :: [[a]]  ->  [[a]]) :: [[a]]  ->  [[a]])

module List where
  import qualified Maybe
import qualified Prelude

  transpose :: [[a]]  ->  [[a]]
transpose [] []
transpose ([] : xsstranspose xss
transpose ((x : xs: xss(x : concatMap transpose0 xss: transpose (xs : concatMap transpose1 xss)

  
transpose0 vv3 transpose00 vv3

  
transpose00 (h : th : []
transpose00 vx []

  
transpose1 vv4 transpose10 vv4

  
transpose10 (h : tt : []
transpose10 vw []


module Maybe where
  import qualified List
import qualified Prelude



Cond Reductions:
The following Function with conditions
undefined 
 | False
 = undefined

is transformed to
undefined  = undefined1

undefined0 True = undefined

undefined1  = undefined0 False



↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ CR
        ↳ HASKELL
          ↳ BR
            ↳ HASKELL
              ↳ COR
HASKELL
                  ↳ Narrow

mainModule List
  (transpose :: [[a]]  ->  [[a]])

module List where
  import qualified Maybe
import qualified Prelude

  transpose :: [[a]]  ->  [[a]]
transpose [] []
transpose ([] : xsstranspose xss
transpose ((x : xs: xss(x : concatMap transpose0 xss: transpose (xs : concatMap transpose1 xss)

  
transpose0 vv3 transpose00 vv3

  
transpose00 (h : th : []
transpose00 vx []

  
transpose1 vv4 transpose10 vv4

  
transpose10 (h : tt : []
transpose10 vw []


module Maybe where
  import qualified List
import qualified Prelude



Haskell To QDPs


↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ CR
        ↳ HASKELL
          ↳ BR
            ↳ HASKELL
              ↳ COR
                ↳ HASKELL
                  ↳ Narrow
                    ↳ AND
QDP
                        ↳ QDPSizeChangeProof
                      ↳ QDP
                      ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_foldr(:(wu310, wu311), ba) → new_foldr(wu311, ba)

R is empty.
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By using the subterm criterion [20] together with the size-change analysis [32] we have proven that there are no infinite chains for this DP problem.

From the DPs we obtained the following set of size-change graphs:



↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ CR
        ↳ HASKELL
          ↳ BR
            ↳ HASKELL
              ↳ COR
                ↳ HASKELL
                  ↳ Narrow
                    ↳ AND
                      ↳ QDP
QDP
                        ↳ QDPSizeChangeProof
                      ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_foldr0(:(wu310, wu311), ba) → new_foldr0(wu311, ba)

R is empty.
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By using the subterm criterion [20] together with the size-change analysis [32] we have proven that there are no infinite chains for this DP problem.

From the DPs we obtained the following set of size-change graphs:



↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ CR
        ↳ HASKELL
          ↳ BR
            ↳ HASKELL
              ↳ COR
                ↳ HASKELL
                  ↳ Narrow
                    ↳ AND
                      ↳ QDP
                      ↳ QDP
QDP
                        ↳ QDPOrderProof
                        ↳ QDPOrderProof

Q DP problem:
The TRS P consists of the following rules:

new_transpose(:([], wu31), ba) → new_transpose(wu31, ba)
new_transpose(:(:(wu300, wu301), wu31), ba) → new_transpose(:(wu301, new_foldr1(wu31, ba)), ba)

The TRS R consists of the following rules:

new_psPs1(:(wu3100, wu3101), wu5, ba) → new_psPs0(wu3101, wu5, app(ty_[], ba))
new_psPs(wu4, ba) → wu4
new_psPs0(wu3100, wu4, ba) → :(wu3100, new_psPs(wu4, ba))
new_foldr1([], ba) → new_foldr2(app(ty_[], ba))
new_psPs1([], wu5, ba) → new_psPs(wu5, app(ty_[], ba))
new_foldr1(:(wu310, wu311), ba) → new_psPs1(wu310, new_foldr1(wu311, ba), ba)
new_foldr2(ba) → []

The set Q consists of the following terms:

new_foldr1([], x0)
new_psPs1([], x0, x1)
new_foldr2(x0)
new_psPs0(x0, x1, x2)
new_psPs(x0, x1)
new_psPs1(:(x0, x1), x2, x3)
new_foldr1(:(x0, x1), x2)

We have to consider all minimal (P,Q,R)-chains.
We use the reduction pair processor [15].


The following pairs can be oriented strictly and are deleted.


new_transpose(:([], wu31), ba) → new_transpose(wu31, ba)
new_transpose(:(:(wu300, wu301), wu31), ba) → new_transpose(:(wu301, new_foldr1(wu31, ba)), ba)
The remaining pairs can at least be oriented weakly.
none
Used ordering: Polynomial interpretation [25]:

POL(:(x1, x2)) = 1 + x1 + x2   
POL([]) = 0   
POL(app(x1, x2)) = 0   
POL(new_foldr1(x1, x2)) = x1   
POL(new_foldr2(x1)) = 0   
POL(new_psPs(x1, x2)) = x1   
POL(new_psPs0(x1, x2, x3)) = 1 + x1 + x2   
POL(new_psPs1(x1, x2, x3)) = 1 + x1 + x2   
POL(new_transpose(x1, x2)) = x1   
POL(ty_[]) = 0   

The following usable rules [17] were oriented:

new_psPs0(wu3100, wu4, ba) → :(wu3100, new_psPs(wu4, ba))
new_foldr2(ba) → []
new_psPs1([], wu5, ba) → new_psPs(wu5, app(ty_[], ba))
new_foldr1(:(wu310, wu311), ba) → new_psPs1(wu310, new_foldr1(wu311, ba), ba)
new_psPs(wu4, ba) → wu4
new_psPs1(:(wu3100, wu3101), wu5, ba) → new_psPs0(wu3101, wu5, app(ty_[], ba))
new_foldr1([], ba) → new_foldr2(app(ty_[], ba))



↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ CR
        ↳ HASKELL
          ↳ BR
            ↳ HASKELL
              ↳ COR
                ↳ HASKELL
                  ↳ Narrow
                    ↳ AND
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                        ↳ QDPOrderProof
QDP
                            ↳ PisEmptyProof
                        ↳ QDPOrderProof

Q DP problem:
P is empty.
The TRS R consists of the following rules:

new_psPs1(:(wu3100, wu3101), wu5, ba) → new_psPs0(wu3101, wu5, app(ty_[], ba))
new_psPs(wu4, ba) → wu4
new_psPs0(wu3100, wu4, ba) → :(wu3100, new_psPs(wu4, ba))
new_foldr1([], ba) → new_foldr2(app(ty_[], ba))
new_psPs1([], wu5, ba) → new_psPs(wu5, app(ty_[], ba))
new_foldr1(:(wu310, wu311), ba) → new_psPs1(wu310, new_foldr1(wu311, ba), ba)
new_foldr2(ba) → []

The set Q consists of the following terms:

new_foldr1([], x0)
new_psPs1([], x0, x1)
new_foldr2(x0)
new_psPs0(x0, x1, x2)
new_psPs(x0, x1)
new_psPs1(:(x0, x1), x2, x3)
new_foldr1(:(x0, x1), x2)

We have to consider all minimal (P,Q,R)-chains.
The TRS P is empty. Hence, there is no (P,Q,R) chain.
We use the reduction pair processor [15].


The following pairs can be oriented strictly and are deleted.


new_transpose(:([], wu31), ba) → new_transpose(wu31, ba)
new_transpose(:(:(wu300, wu301), wu31), ba) → new_transpose(:(wu301, new_foldr1(wu31, ba)), ba)
The remaining pairs can at least be oriented weakly.
none
Used ordering: Matrix interpretation [3]:
Non-tuple symbols:
M( new_foldr1(x1, x2) ) =
/1\
\0/
+
/01\
\01/
·x1+
/00\
\00/
·x2

M( new_foldr2(x1) ) =
/0\
\0/
+
/00\
\00/
·x1

M( [] ) =
/0\
\0/

M( app(x1, x2) ) =
/0\
\0/
+
/00\
\00/
·x1+
/00\
\00/
·x2

M( new_psPs1(x1, ..., x3) ) =
/0\
\1/
+
/00\
\01/
·x1+
/10\
\01/
·x2+
/00\
\00/
·x3

M( new_psPs(x1, x2) ) =
/0\
\0/
+
/10\
\01/
·x1+
/00\
\00/
·x2

M( new_psPs0(x1, ..., x3) ) =
/0\
\1/
+
/00\
\01/
·x1+
/00\
\01/
·x2+
/00\
\00/
·x3

M( :(x1, x2) ) =
/0\
\1/
+
/00\
\01/
·x1+
/00\
\01/
·x2

M( ty_[] ) =
/0\
\0/

Tuple symbols:
M( new_transpose(x1, x2) ) = 0+
[0,1]
·x1+
[0,0]
·x2


Matrix type:
We used a basic matrix type which is not further parametrizeable.


As matrix orders are CE-compatible, we used usable rules w.r.t. argument filtering in the order.
The following usable rules [17] were oriented:

new_psPs0(wu3100, wu4, ba) → :(wu3100, new_psPs(wu4, ba))
new_foldr2(ba) → []
new_psPs1([], wu5, ba) → new_psPs(wu5, app(ty_[], ba))
new_foldr1(:(wu310, wu311), ba) → new_psPs1(wu310, new_foldr1(wu311, ba), ba)
new_psPs(wu4, ba) → wu4
new_psPs1(:(wu3100, wu3101), wu5, ba) → new_psPs0(wu3101, wu5, app(ty_[], ba))
new_foldr1([], ba) → new_foldr2(app(ty_[], ba))



↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ CR
        ↳ HASKELL
          ↳ BR
            ↳ HASKELL
              ↳ COR
                ↳ HASKELL
                  ↳ Narrow
                    ↳ AND
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                        ↳ QDPOrderProof
                        ↳ QDPOrderProof
QDP

Q DP problem:
P is empty.
The TRS R consists of the following rules:

new_psPs1(:(wu3100, wu3101), wu5, ba) → new_psPs0(wu3101, wu5, app(ty_[], ba))
new_psPs(wu4, ba) → wu4
new_psPs0(wu3100, wu4, ba) → :(wu3100, new_psPs(wu4, ba))
new_foldr1([], ba) → new_foldr2(app(ty_[], ba))
new_psPs1([], wu5, ba) → new_psPs(wu5, app(ty_[], ba))
new_foldr1(:(wu310, wu311), ba) → new_psPs1(wu310, new_foldr1(wu311, ba), ba)
new_foldr2(ba) → []

The set Q consists of the following terms:

new_foldr1([], x0)
new_psPs1([], x0, x1)
new_foldr2(x0)
new_psPs0(x0, x1, x2)
new_psPs(x0, x1)
new_psPs1(:(x0, x1), x2, x3)
new_foldr1(:(x0, x1), x2)

We have to consider all minimal (P,Q,R)-chains.